{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Softmax exercise\n",
    "\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "完成并连同作业缴交此完整的工作表(包括其输出及工作表外的任何支援程式码)。\n",
    "\n",
    "This exercise is analogous to the SVM exercise. You will:\n",
    "\n",
    "- implement a fully-vectorized **loss function** for the Softmax classifier\n",
    "- implement the fully-vectorized expression for its **analytic gradient**\n",
    "- **check your implementation** with numerical gradient\n",
    "- use a validation set to **tune the learning rate and regularization** strength\n",
    "- **optimize** the loss function with **SGD**\n",
    "- **visualize** the final learned weights\n",
    "\n",
    "这个练习类似于SVM练习。你会:\n",
    "\n",
    "-为Softmax分类器实现一个完全向量化的**损失函数**\n",
    "\n",
    "-实现其**解析梯度**的全向量化表达式\n",
    "\n",
    "-**检查你的实现**用数值梯度\n",
    "\n",
    "-使用验证集**调整学习率和正则化**强度\n",
    "\n",
    "-用**SGD** **优化**损耗函数\n",
    "\n",
    "-**可视化**最后学习的权重\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3073)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3073)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3073)\n",
      "Test labels shape:  (1000,)\n",
      "dev data shape:  (500, 3073)\n",
      "dev labels shape:  (500,)\n"
     ]
    }
   ],
   "source": [
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the linear classifier. These are the same steps as we used for the\n",
    "    SVM, but condensed to a single function.  \n",
    "    从磁盘加载CIFAR-10数据集并执行预处理，为线性分类器做好准备。\n",
    "    这些步骤与我们在SVM中使用的步骤相同，但是被压缩为一个函数。\n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "#     cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    cifar10_dir = 'E:\\cifar-10-batches-py'\n",
    "\n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    mask = np.random.choice(num_training, num_dev, replace=False)\n",
    "    X_dev = X_train[mask]\n",
    "    y_dev = y_train[mask]\n",
    "    \n",
    "    # Preprocessing: reshape the image data into rows\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n",
    "    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n",
    "    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n",
    "    \n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis = 0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "    X_dev -= mean_image\n",
    "    \n",
    "    # add bias dimension and transform into columns\n",
    "    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n",
    "    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n",
    "    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n",
    "    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n",
    "\n",
    "\n",
    "# 调用上面的函数来获取数据。\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)\n",
    "print('dev data shape: ', X_dev.shape)\n",
    "print('dev labels shape: ', y_dev.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Softmax Classifier\n",
    "\n",
    "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n",
    "\n",
    "分类评分向量f中的第j个元素 softmax 函数：$f_j(z)=\\frac{e^{z_j}}{\\sum_ke^{z_k}}$\n",
    "\n",
    "样本$i$的交叉熵损失（cross-entropy loss）：$\\displaystyle L_i=-log(\\frac{e^{f_{y_j}}}{\\sum_je^{f_j}})=-f_{y_j}+log(\\sum_je^{f_j})$\n",
    "\n",
    "https://blog.csdn.net/zt_1995/article/details/62227603\n",
    "\n",
    "<!-- ![image.png](attachment:image.png) -->\n",
    "\n",
    "<img src=\"https://img-blog.csdn.net/20170315160017179?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvenRfMTk5NQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast\" align=left width=\"50%\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss: 2.365876\n",
      "sanity check: 2.302585\n"
     ]
    }
   ],
   "source": [
    "# First implement the naive softmax loss function with nested loops.\n",
    "# 首先用嵌套循环实现naive softmax损失函数。\n",
    "# Open the file cs231n/classifiers/softmax.py and implement the\n",
    "# softmax_loss_naive function.\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_naive\n",
    "import time\n",
    "\n",
    "# 生成一个随机softmax权重矩阵，用它来计算损失。\n",
    "# Generate a random softmax weight matrix and use it to compute the loss.\n",
    "W = np.random.randn(3073, 10) * 0.0001\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# 作为一个粗略的完整性检查，我们的损失应该接近-log(0.1)。\n",
    "# As a rough sanity check, our loss should be something close to -log(0.1).\n",
    "print('loss: %f' % loss)\n",
    "print('sanity check: %f' % (-np.log(0.1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 1**\n",
    "\n",
    "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numerical: -1.094300 analytic: -1.094300, relative error: 2.248100e-08\n",
      "numerical: -1.053050 analytic: -1.053050, relative error: 5.508845e-09\n",
      "numerical: -0.843324 analytic: -0.843324, relative error: 3.254824e-08\n",
      "numerical: -1.099520 analytic: -1.099520, relative error: 6.552973e-09\n",
      "numerical: 1.421796 analytic: 1.421796, relative error: 6.204344e-10\n",
      "numerical: -2.396471 analytic: -2.396471, relative error: 1.041955e-08\n",
      "numerical: -0.082480 analytic: -0.082481, relative error: 2.442208e-07\n",
      "numerical: 3.402114 analytic: 3.402113, relative error: 2.458817e-08\n",
      "numerical: -2.605815 analytic: -2.605815, relative error: 1.714215e-08\n",
      "numerical: 1.290679 analytic: 1.290679, relative error: 4.620806e-08\n",
      "numerical: 2.630304 analytic: 2.630303, relative error: 1.150446e-08\n",
      "numerical: 1.046108 analytic: 1.046108, relative error: 6.059228e-08\n",
      "numerical: 0.443694 analytic: 0.443694, relative error: 1.133080e-07\n",
      "numerical: -0.790526 analytic: -0.790526, relative error: 1.104412e-08\n",
      "numerical: 1.132381 analytic: 1.132381, relative error: 4.916166e-08\n",
      "numerical: 0.097406 analytic: 0.097406, relative error: 2.685859e-07\n",
      "numerical: -0.777947 analytic: -0.777947, relative error: 2.019202e-08\n",
      "numerical: -3.741255 analytic: -3.741255, relative error: 7.559435e-10\n",
      "numerical: 0.707784 analytic: 0.707784, relative error: 8.995217e-08\n",
      "numerical: -0.293240 analytic: -0.293240, relative error: 1.603003e-07\n"
     ]
    }
   ],
   "source": [
    "# Complete the implementation of softmax_loss_naive and implement a (naive)\n",
    "# version of the gradient that uses nested loops.\n",
    "# 完成softmax_loss_naive的实现，并实现一个梯度的(naive)版本，使用嵌套循环。\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n",
    "\n",
    "# 与支持向量机一样，使用数值梯度检查作为调试工具。\n",
    "# 数值梯度应接近解析梯度。\n",
    "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n",
    "# The numeric gradient should be close to the analytic gradient.\n",
    "from cs231n.gradient_check import grad_check_sparse\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)\n",
    "\n",
    "# 与SVM的情况类似，用正则化方法再做一次梯度检查\n",
    "# similar to SVM case, do another gradient check with regularization\n",
    "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n",
    "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n",
    "grad_numerical = grad_check_sparse(f, W, grad, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "naive loss: 2.365876e+00 computed in 0.229162s\n",
      "vectorized loss: 2.365876e+00 computed in 0.015353s\n",
      "Loss difference: 0.000000\n",
      "Gradient difference: 0.000000\n"
     ]
    }
   ],
   "source": [
    "# Now that we have a naive implementation of the softmax loss function and its gradient,\n",
    "# implement a vectorized version in softmax_loss_vectorized.\n",
    "# The two versions should compute the same results, but the vectorized version should be\n",
    "# much faster.\n",
    "# 现在，我们已经有了softmax损失函数及其梯度的简单实现，\n",
    "# 在softmax_loss_vectorized中实现一个向量化版本。\n",
    "# 这两个版本应该计算相同的结果，但是向量化的版本应该快得多。\n",
    "tic = time.time()\n",
    "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n",
    "\n",
    "from cs231n.classifiers.softmax import softmax_loss_vectorized\n",
    "tic = time.time()\n",
    "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n",
    "toc = time.time()\n",
    "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n",
    "\n",
    "# 与支持向量机一样，我们使用Frobenius范数来比较两个版本的梯度。\n",
    "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n",
    "# of the gradient.\n",
    "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n",
    "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n",
    "print('Gradient difference: %f' % grad_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.352143 val accuracy: 0.369000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.327653 val accuracy: 0.347000\n",
      "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.348204 val accuracy: 0.353000\n",
      "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.326653 val accuracy: 0.345000\n",
      "best validation accuracy achieved during cross-validation: 0.369000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune hyperparameters (regularization strength and\n",
    "# learning rate). You should experiment with different ranges for the learning\n",
    "# rates and regularization strengths; if you are careful you should be able to\n",
    "# get a classification accuracy of over 0.35 on the validation set.\n",
    "# 使用验证集来调整超参数(正则化强度和学习率)。\n",
    "# 你应该尝试不同的学习速率和正则化强度范围;\n",
    "# 如果您小心的话，您应该能够在验证集上获得超过0.35的分类精度。\n",
    "from cs231n.classifiers import Softmax\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_softmax = None\n",
    "learning_rates = [1e-7, 5e-7]\n",
    "regularization_strengths = [2.5e4, 5e4]\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained softmax classifer in best_softmax.                          #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 使用验证集设置学习速率和正则化强度。\n",
    "# 这应该与SVM的验证相同;\n",
    "# 保存最佳训练的softmax分类器在best_softmax。\n",
    "pass\n",
    "for lr in learning_rates:\n",
    "    for rs in regularization_strengths:\n",
    "        softmax = Softmax()\n",
    "        softmax.train(X_train, y_train, lr, rs, num_iters=2000)\n",
    "        y_train_pred = softmax.predict(X_train)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = softmax.predict(X_val)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_softmax = softmax           \n",
    "        results[(lr,rs)] = train_accuracy, val_accuracy\n",
    "        \n",
    "\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "    \n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "softmax on raw pixels final test set accuracy: 0.363000\n"
     ]
    }
   ],
   "source": [
    "# evaluate on test set\n",
    "# Evaluate the best softmax on test set\n",
    "y_test_pred = best_softmax.predict(X_test)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question 2** - *True or False*\n",
    "\n",
    "Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n",
    "\n",
    "假设总体训练损失被定义为所有训练示例中每个数据点损失的总和。\n",
    "\n",
    "可以向训练集添加一个新的数据点，使SVM的损失保持不变，但Softmax分类器的损失不是这种情况。\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the learned weights for each class\n",
    "w = best_softmax.W[:-1,:] # strip out the bias\n",
    "w = w.reshape(32, 32, 3, 10)\n",
    "\n",
    "w_min, w_max = np.min(w), np.max(w)\n",
    "\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for i in range(10):\n",
    "    plt.subplot(2, 5, i + 1)\n",
    "    \n",
    "    # Rescale the weights to be between 0 and 255\n",
    "    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n",
    "    plt.imshow(wimg.astype('uint8'))\n",
    "    plt.axis('off')\n",
    "    plt.title(classes[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.78979955 0.04887747 0.22957192]\n",
      " [0.82150647 0.12743317 0.49687003]\n",
      " [0.35451674 0.44862581 0.073524  ]\n",
      " [0.0344621  0.97465547 0.19927504]\n",
      " [0.59111263 0.23095339 0.91562976]]\n",
      "range(0, 5)\n",
      "[[1 2 1 0 2]]\n",
      "[array([1, 2, 1, 0, 2])]\n",
      "[[0.04887747 0.49687003 0.44862581 0.0344621  0.91562976]]\n",
      "[[0.04887747 0.49687003 0.44862581 0.0344621  0.91562976]]\n",
      "(1, 5)\n",
      "1.9444651599009182\n"
     ]
    }
   ],
   "source": [
    "# # softmax函数输出 (N, C)\n",
    "# num_train = 5\n",
    "# softmax_output=np.random.random((num_train ,3))\n",
    "# print(softmax_output)\n",
    "# # softmax_output=np.array([])\n",
    "# y = np.array([[1],[2],[1],[0],[2]]).reshape(1,-1)\n",
    "\n",
    "# print(range(num_train))\n",
    "# print(y)\n",
    "# print(list(y))\n",
    "# print(softmax_output[range(num_train), y])\n",
    "# print(softmax_output[range(num_train), list(y)])\n",
    "# print(softmax_output[range(num_train), list(y)].shape)\n",
    "# print(np.sum(softmax_output[range(num_train), list(y)]))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "307.188px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
